package com.moody.calculator;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.moody.hibernate.domain.ReportData;

/*
 * Copyright © Moody analytics  
 *
 * @Title: SmallFinancialIndexCalculator.java 
 * @Package： com.moody.calculator 
 * @author： Fuqiang Wang
 * @Description: 小企业财务报表计算公式    
 * @date： 2012-2-24 下午2:42:16
 * @Modified by: Fuqiang Wang 
 * @version V2.0   
 */

public class SmallFinancialIndexCalculator {
	private static final Logger log = LoggerFactory.getLogger(SmallFinancialIndexCalculator.class);

	private Map<String,Double> currentMap = new HashMap<String,Double>();     //今年
	private Map<String,Double> lastMap = new HashMap<String,Double>();		//去年
	private Map<String,Double> resultMap = new LinkedHashMap<String,Double>();
	private List<ReportData> reportDataList1;
	private List<ReportData> reportDataList2;
	
	
	public SmallFinancialIndexCalculator(List<ReportData> reportDataList1, List<ReportData> reportDataList2){
		this.reportDataList1 = reportDataList1;
		this.reportDataList2 = reportDataList2;
	}

	//将数据存入map中，包含所有计算财务指标所需要的数据
	public void loadData(){
		if(reportDataList1!=null){
			for(ReportData  rd : reportDataList1){
				currentMap.put(rd.getReportItemNo(), rd.getItemValue());
			}
		}
		if(reportDataList2!=null){
			for(ReportData rd : reportDataList2){
				lastMap.put(rd.getReportItemNo(), rd.getItemValue());
			}
		}
	}
	
	public void computeIndex(){
		//最好是多线程处理
		SmallFinancialIndexCalculator fic = new SmallFinancialIndexCalculator(reportDataList1,reportDataList2);
		fic.loadData();
		Method[] methods = SmallFinancialIndexCalculator.class.getDeclaredMethods();
		for(Method  method : methods){
			String name = method.getName();
			//抽取所有以calculate的方法，表示是计算公式
			if(name.startsWith("calculate")){
				try {
					//reportData名
					name = name.substring("calculate".length(), name.length());
					resultMap.put(name, (Double) method.invoke(fic));
				} catch (Exception e) {
					log.error("该项计算有误",e);
				} 
			}
		}
	}
	
	public Map<String,Double> getResultMap(){
		return resultMap;
	}
	
	/*
	 * 以下为所有的财务指标计算公式
	 */

	//判断double类型是否为0
	public Boolean isZero(Double data){
		if(data >10E-6 || data <-(10E-6))
			return false;
		else
			return true;
	}
	
	 
    /* 
     * 短期偿债能力 
     */ 
     
    //由于计算公式和一般企业的公式基本一致，为了方便起见，所以这里变量名未修改，只是修改获取的数据为小企业的数据 
    //流动比率 
    public Double calculateSFR001(){ 
            Double SBS011 = currentMap.get("SBS011"); 
            Double SBS039 = currentMap.get("SBS039"); 

            if(SBS011!=null && SBS039!=null && !isZero(SBS039)) 
                    return SBS011/SBS039; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    
	/*
	 * 此公式经过修改
	 * By Fuqiang
	 */
    //速动比率 
    public Double calculateSFR002(){ 
    	Double SBS011 = currentMap.get("SBS011");
		Double SBS007 = currentMap.get("SBS007");
		Double SBS039 = currentMap.get("SBS039");
		if(SBS011!=null && SBS007!=null &&  SBS039!=null && !isZero((SBS039)))
			return (SBS011-SBS007)/SBS039;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
    } 
    //现金流动负债比率a （更改为现金比率）
    public Double calculateSFR003(){ 
            Double SBS001 = currentMap.get("SBS001");//货币资金
            Double EBS043 = currentMap.get("SBS039"); 
            if(SBS001!=null && EBS043!=null && !isZero(EBS043)) 
                    return SBS001/EBS043; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //现金流动负债比率b 
    public Double calculateSFR004(){ 
            Double ECF014 = currentMap.get("SCF009"); 
            Double ECF035 = currentMap.get("SCF025"); 
            Double EBS043 = currentMap.get("SBS039"); 
            if(currentMap.get("SCF014")!=null && currentMap.get("SCF035")!=null  
                            && currentMap.get("SBS043")!=null && !isZero(currentMap.get("SBS043"))) 
                    return (currentMap.get("SCF014")-currentMap.get("SCF035"))/currentMap.get("SBS043"); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 

    //现金到期债务比 
    public Double calculateSFR005(){ 
            Double SCF019 = currentMap.get("SCF019"); 
            Double SBS037 = currentMap.get("SBS037"); 
            Double SBS027 = currentMap.get("SBS027"); 
            Double SBS028 = currentMap.get("SBS028"); 
             
            if(SCF019!=null && SBS037!=null && SBS027!=null && SBS028!=null && !isZero(SBS037+SBS027+SBS028)) 
                    return SCF019/(SBS037+SBS027+SBS028); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //净负债率 
    public Double calculateSFR006(){ 
            Double SBS027 = currentMap.get("SBS027"); 
            Double SBS037 = currentMap.get("SBS037"); 
            Double SBS040 = currentMap.get("SBS040"); 
            Double SBS001 = currentMap.get("SBS001"); 
            Double SBS050 = currentMap.get("SBS050"); 
             
            if(SBS027!=null && SBS037!=null && SBS040!=null && SBS001 !=null && !isZero(SBS050)) 
                    return (SBS027+SBS037+SBS040-SBS001)/SBS050; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //全部资本化比率 
    public Double calculateSFR007(){ 
            Double SBS027 = currentMap.get("SBS027"); 
            Double SBS028 = currentMap.get("SBS028"); 
            Double SBS037 = currentMap.get("SBS037"); 
            Double SBS040 = currentMap.get("SBS040"); 
            Double SBS050 = currentMap.get("SBS050"); 
             
            if(SBS027!=null && SBS028!=null && SBS037!=null && SBS040!=null && SBS050!=null  
                     && !isZero(SBS027 + SBS028 + SBS037 + SBS040 + SBS050)){ 
                    return (SBS027 + SBS028 + SBS037 + SBS040) /  
                              (SBS027 + SBS028 + SBS037 + SBS040 + SBS050); 
            } 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    /* 
     * 长期偿债能力 
     */ 
    //资产负债率 
    public Double calculateSFR008(){ 
            Double SBS044 = currentMap.get("SBS044"); 
            Double SBS026 = currentMap.get("SBS026"); 
             
            if(SBS044!=null && SBS026!=null && !isZero(SBS026)) 
                    return SBS044/SBS026; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //长期资本负债率 
    public Double calculateSFR009(){ 
            Double SBS044 = currentMap.get("SBS044"); 
            Double SBS039 = currentMap.get("SBS039"); 
            Double SIS001 = currentMap.get("SIS001"); 
             
             
            if(SBS044!=null && SBS039!=null && SIS001!=null && !isZero(SIS001)) 
                    return (SBS044 - SBS039) / (SIS001); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //有形净值与债务比率 
    public Double calculateSFR010(){ 
            Double EBS069 = currentMap.get("SBS050"); 
            Double EBS033 = currentMap.get("SBS022"); 
            Double EBS068 = currentMap.get("SBS044"); 
             
            if(EBS069!=null && EBS033!=null && EBS068!=null && !isZero(EBS068)){ 
                    return (EBS069-EBS033)/EBS068; 
            }else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 

    //利息保障倍数 
    //利润表中无：财务费用  
    public Double calculateSFR011(){ 
            Double EIS017 = currentMap.get("SIS014"); 
            Double EIS007 = currentMap.get("SIS008"); 
             
            if(EIS017!=null && EIS007!=null && !isZero(EIS007)){ 
                    return (EIS017+EIS007)/EIS007; 
            }else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //偿债覆盖比率 
    public Double calculateSFR012(){ 
            Double ECF014 = currentMap.get("SCF009"); 
            Double EBS068= currentMap.get("SBS044"); 
             
            if(ECF014!=null && EBS068!=null && !isZero(EBS068)){ 
                    return ECF014/EBS068; 
            }else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     

    // 长期偿债能力，与现金流量表相关的数据   
    //现金利息保障倍数 
    public Double calculateSFR013(){ 
            Double ECF014 = currentMap.get("SCF009"); 
            Double EIS026 = currentMap.get("SIS008"); 
             
            if(ECF014!=null &&  EIS026!=null && !isZero(EIS026)) 
                    return ECF014/EIS026; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //收入利息保障倍数 
    public Double calculateSFR014(){ 
            Double SIS001 = currentMap.get("SIS001"); 
            Double SIS008 = currentMap.get("SIS008"); 
             
            if(SIS001!=null &&  SIS008!=null  && !isZero(SIS008)) 
                    return (SIS001)/(SIS008); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //利润债务保障倍数 
    public Double calculateSFR015(){                 
            Double SIS008 = currentMap.get("SIS008"); 
            Double SIS014 = currentMap.get("SIS014"); 
            Double SBS027 = currentMap.get("SBS027"); 
            Double SBS028 = currentMap.get("SBS028"); 
            Double SBS037 = currentMap.get("SBS037"); 
            Double SBS040 = currentMap.get("SBS040"); 

            if(SIS008!=null &&  SIS014!=null &&  SBS027!=null &&  SBS028!=null &&  SBS037!=null &&  SBS040!=null 
                    && !isZero(SBS027+SBS028+SBS037+SBS040)) 
                    return (SIS008+SIS014)/((SBS027+SBS028+SBS037+SBS040)); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //单位资产长期负债 
    public Double calculateSFR016(){ 
            Double SBS044 = currentMap.get("SBS044"); 
            Double SBS026 = currentMap.get("SBS026"); 
             
            if(SBS044!=null &&  SBS026!=null  && !isZero(SBS026)) 
                    return SBS044/SBS026; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 

    //非流动负债与收入比率  
    public Double calculateSFR017(){ 
            Double SBS044 = currentMap.get("SBS044"); 
            Double SBS039 = currentMap.get("SBS039"); 
            Double SIS001 = currentMap.get("SIS001"); 
     
            if(SBS044 != null && SBS039 != null && SIS001 !=null && !isZero(SIS001)){ 
                    return (SBS044 - SBS039) / SIS001; 
            }else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //应收账款负债率 
    public Double calculateSFR018(){ 

            Double SBS005 = currentMap.get("SBS005"); //应收账款
            Double SBS043 = currentMap.get("SBS043"); //长期负债合计
            Double SBS039 = currentMap.get("SBS039"); //流动负债合计
             
            if(SBS005!=null && SBS043!=null && SBS039!=null && !isZero(SBS043+SBS039)) 
                    return SBS005/(SBS043+SBS039); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //长期负债权益比率 
    public Double calculateSFR019(){ 
            Double SBS043 = currentMap.get("SBS043"); 
            Double SBS050 = currentMap.get("SBS050"); 
             
            if(SBS043!=null && SBS050!=null && !isZero(SBS050)) 
                    return (SBS043)/SBS050; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    
	//长期负债权益比率
	public Double calculateSFR082(){
		Double EBS045 = currentMap.get("SBS027");//短期借款
		Double EBS061 = currentMap.get("SBS040");//长期借款
//		Double EBS013 = currentMap.get("SBS003");//应收票据
		Double EBS058 = currentMap.get("SBS037");//一年内到期的长期负债
		Double EBS069 = currentMap.get("SBS050");//所有者权益（或股东权益）合计
		
		if(EBS045!=null && EBS061!=null && EBS058!=null && EBS058!=null 
				&& !isZero(EBS069))
			return (EBS061+EBS045+EBS058)/EBS069;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
    
    //收入与非流动负债比 
    public Double calculateSFR020(){ 
            Double EIS016 = currentMap.get("EIS016"); 
            Double SIS008 = currentMap.get("SIS008"); 
            Double SBS044 = currentMap.get("SBS044"); 
            Double SBS039 = currentMap.get("SBS039"); 
             
            if(EIS016!=null && SIS008!=null && SBS044!=null && SBS039!=null  
                            && !isZero(SBS044-SBS039)) 
                    return (EIS016+SIS008)/(SBS044-SBS039); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //收入负债比 
    public Double calculateSFR021(){ 
            Double EIS016 = currentMap.get("EIS016"); 
            Double SIS008 = currentMap.get("SIS008"); 
            Double SBS044 = currentMap.get("SBS044"); 
             
            if(EIS016!=null && SIS008!=null && SBS044!=null&& !isZero(SBS044)) 
                    return (EIS016+SIS008)/(SBS044); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    /* 
     * 营运能力 
     */ 

    //应收账款周转率 
    public Double calculateSFR022(){         
            Double SIS001 = currentMap.get("SIS001"); 
            Double SBS005 = currentMap.get("SBS005"); 
            Double lastSBS005 = lastMap.get("SBS005"); 
            
    		if(SIS001!=null && SBS005!=null && lastSBS005==null && !isZero(SBS005)){
    			return SIS001 / SBS005 * 2;
    		}
     
            if(SIS001!=null && SBS005!=null && lastSBS005!=null && !isZero(SBS005+lastSBS005) ) 
                    return SIS001 / (SBS005+lastSBS005)*2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
//          //公式2：主营业务收入 /[(期初应收账款及应收票据+期末应收账款及应收票据）/2]
//        	Double SIS001 = currentMap.get("SIS001");//一、主营业务收入
//            
//        	Double SBS003 = currentMap.get("SBS003");//应收票据
//            Double SBS005 = currentMap.get("SBS005"); //应收账款
//            Double lastSBS003 = lastMap.get("SBS003");//去年：应收票据
//            Double lastSBS005 = lastMap.get("SBS005"); //去年：应收账款
//            
//            
//             
//            if(SBS005!=null && SIS001!=null && SBS003!=null  && lastSBS005!=null  && lastSBS003!=null && !isZero(SBS003 + SBS005 + lastSBS003 + lastSBS005)) 
//                    return 2 * SIS001/(SBS003 + SBS005 + lastSBS003 + lastSBS005); 
//            else{ 
//                    log.error("数据项不存在或分母为空"); 
//                    return null; 
//            }
    } 

	//应收账款周转天数
	public Double calculateSFR078(){
		Double SFR022 = calculateSFR022();
		if(SFR022 == null || SFR022 == 0) return null;
		else return 365 / SFR022;
	}

    //存货周转率 
    public Double calculateSFR023(){ 
            Double EIS002 = currentMap.get("SIS002"); 
            Double EBS008 = currentMap.get("SBS007"); 
            Double lastEBS008 = lastMap.get("SBS007"); 
             
            if(EIS002!=null && EBS008 !=null && lastEBS008 !=null && !isZero(EBS008+lastEBS008)) 
                    return 2 * EIS002 / (EBS008 + lastEBS008); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 

	//存货周转天数
	public Double calculateSFR080(){
		Double SFR023 = calculateSFR023();
		if(SFR023 == null || SFR023 == 0) return null;
		else return 365 / SFR023;
	}
     
    //流动资产周转率 
    public Double calculateSFR024(){ 
            Double EIS001 = currentMap.get("EIS001"); 
            Double EBS003 = currentMap.get("SBS011"); 
            Double lastEBS003 = currentMap.get("SBS011"); 
             
            if(EIS001!=null && EBS003!=null && lastEBS003!=null && !isZero(EBS003+lastEBS003)) 
                    return EIS001 / (EBS003 + lastEBS003)*2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 

    //固定资产周转率 
    public Double calculateSFR025(){ 
            Double EIS001 = currentMap.get("EIS001"); 
            Double EBS020 = currentMap.get("SBS017"); 
            Double lastEBS020 = lastMap.get("SBS017"); 
             
            if(EIS001!=null && EBS020!=null && lastEBS020!=null && !isZero(EBS020+lastEBS020)) 
                    return EIS001 / (EBS020 + lastEBS020)*2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    //总资产周转率 
    public Double calculateSFR026(){ 
            Double EIS001 = currentMap.get("SIS001"); 
            Double EBS041 = currentMap.get("SBS026"); 
            Double lastEBS041 = lastMap.get("SBS026"); 
             
            if(EIS001!=null && EBS041!=null && lastEBS041!=null && !isZero(EBS041+lastEBS041)) 
                    return EIS001 / (EBS041 + lastEBS041)*2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            }        
    } 

	//总资产周转天数
	public Double calculateSFR081(){
		Double SFR026 = calculateSFR026();
		if(SFR026 == null  || SFR026 == 0) return null;
		else return 365 / SFR026;
	}
     
    //资产现金回收率  
    public Double calculateSFR027(){ 
            Double ECF014 = currentMap.get("SCF009"); 
            Double EBS041 = currentMap.get("SBS026"); 
            Double lastEBS041 = lastMap.get("SBS026"); 
             
            if(ECF014!=null && EBS041!=null && lastEBS041!=null && !isZero(EBS041+lastEBS041)) 
                    return ECF014/(EBS041+lastEBS041)*2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            }        
    } 
     

    //应付账款周转率 
    public Double calculateSFR028(){ 
    	
        //公式2：主营业务成本 / [（应付账款期初余额+应付账款期末余额）/2]
        Double EIS002 = currentMap.get("SIS002");  //减:主营业务成本
        Double EBS047 = currentMap.get("SBS029"); //应付账款期末余额
        Double lastEBS047 = lastMap.get("SBS029"); //应付账款期初余额
         
        if(EIS002!=null && EBS047!=null && lastEBS047==null && !isZero(EBS047)) 
            return EIS002 / EBS047 ; 
        
        if(EIS002!=null && EBS047!=null && lastEBS047!=null && !isZero(EBS047+lastEBS047)) 
                return EIS002 / (EBS047 + lastEBS047)*2 ; 
        else{ 
                log.error("数据项不存在或分母为空"); 
                return null; 
        } 
    } 

	//应收账款周转天数
	public Double calculateSFR079(){
		Double SFR028 = calculateSFR028();
		if(SFR028 == null  || SFR028 == 0) return null;
		else return 365 / SFR028;
	}
     
    //营运资本周转期 
    public Double calculateSFR029(){ 
            Double EBS003 = currentMap.get("SBS011"); 
            Double lastEBS003 = lastMap.get("SBS011"); 
            Double EBS019 = currentMap.get("SBS039"); 
            Double lastEBS019 = lastMap.get("SBS039"); 
            Double EIS001 = currentMap.get("SIS001"); 
             
            if(EBS003!=null && lastEBS003!=null && EBS019!=null && lastEBS019!=null && !isZero(lastEBS019)) 
                    return (EBS003+lastEBS003-EBS019-lastEBS019)*2/EIS001; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    /* 
     * 盈利能力 
     */ 
	/*
	 * 此公式经过修改，by Fuqiang
	 */
    //总资产报酬率 :净利润/总资产
    public Double calculateSFR030(){ 
            Double EIS019 = currentMap.get("SIS016"); //净利润
            Double EBS041 = currentMap.get("SBS026"); 
//            Double lastEBS041 = lastMap.get("SBS026"); 
             
            if(EIS019!=null &&  EBS041!=null && !isZero(EBS041)) 
                    return EIS019 /EBS041; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //长期资金报酬率 
    public Double calculateSFR031(){ 
            Double EIS016 = currentMap.get("SIS014"); 
            Double EIS026 = currentMap.get("SIS008"); 
            Double EBS061 = currentMap.get("SBS043"); 
            Double EBS063 = currentMap.get("SBS050"); 
             
            Double lastEBS061 = lastMap.get("SBS043"); 
            Double lastEBS063 = lastMap.get("SBS050"); 

             
            if(EIS016!=null && EIS026 !=null &&EBS061!=null && lastEBS061!=null && lastEBS063!=null &&  
                            !isZero(EBS061 + EBS063 + lastEBS061 + lastEBS063)) 
                    return (EIS016+EIS026)/(EBS061 + EBS063 + lastEBS061 + lastEBS063)*2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //净资产报酬率 
    public Double calculateSFR032(){ 
            Double EIS019 = currentMap.get("SIS016"); 
            Double EBS069 = currentMap.get("SBS050"); 
            Double lastEBS069 = lastMap.get("SBS050"); 
             
            if(EIS019!=null &&  EBS069!=null && lastEBS069!=null && !isZero(EBS069+lastEBS069)) 
                    return EIS019/(lastEBS069+EBS069)*2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //主营业务毛利率 (更改为：销售利润率)
	//计算公式如下：利润总额/主营业务收入(销售收入)
    public Double calculateSFR033(){ 
            Double EIS002 = currentMap.get("SIS001"); 
            Double EIS003 = currentMap.get("SIS002");
            
            Double EIS019 = currentMap.get("SIS014"); //利润总额
             
            if(EIS002!=null && EIS019!=null && !isZero(EIS002)) 
                    return EIS019/EIS002; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //成本费用利润率 
    public Double calculateSFR034(){ 
            Double EBS016 = currentMap.get("SIS014"); 
            Double EIS003 = currentMap.get("SIS002"); 
            Double EIS004 = currentMap.get("SIS003"); 
            Double EIS005 = currentMap.get("SIS006"); 
            Double EIS006 = currentMap.get("SIS007"); 
            Double EIS026 = currentMap.get("SIS008"); 

            if(EBS016!=null && EIS003!=null && EIS004!=null && EIS005!=null && EIS006!=null && EIS026!=null && 
                            !isZero(EIS003+EIS004+EIS005+EIS006+EIS026)) 
                    return EBS016/(EIS003+EIS004+EIS005+EIS006+EIS026); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //资本收益率 
    public Double calculateSFR035(){ 
            Double EIS019 = currentMap.get("SIS014"); 
            Double EBS070 = currentMap.get("SBS045"); 
            Double lastEBS070 = lastMap.get("SBS045"); 
            Double EBS072 = currentMap.get("SBS046"); 
            Double lastEBS072 = lastMap.get("SBS046"); 
             
            if(EIS019!=null && EBS070!=null &&  lastEBS070!=null && EBS072!=null  
                            && lastEBS072!=null && !isZero(EBS070 + lastEBS070 + EBS072 + lastEBS072)) 
                    return EIS019 / (EBS070 + lastEBS070 + EBS072 + lastEBS072) * 2; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //主营业务净利率 
    public Double calculateSFR036(){ 
            Double EIS019 = currentMap.get("SIS016"); //五、净利润
            Double EIS001 = currentMap.get("SIS001"); //一、主营业务收入
             
            if(EIS019!=null && EIS001!=null && !isZero(EIS001)) 
                    return EIS019/EIS001; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //折旧摊销覆盖率
    public Double calculateSFR037(){
    	return null;
    }
    //息税前利润率
    public Double calculateSFR038(){ 
//            Double EIS026 = currentMap.get("SIS012"); 
            Double EIS016 = currentMap.get("SIS014"); //四、利润总额
            Double EBS041 = currentMap.get("SIS001"); //一、主营业务收入
             
            if( EIS016!=null && EBS041!=null && !isZero(EBS041)) 
                    return (EIS016)/EBS041; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //单位资产利润 
    public Double calculateSFR039(){ 
            Double EIS016 = currentMap.get("SIS012"); 
            Double EBS041 = currentMap.get("SBS026");  
             
            if(EIS016 !=null && EBS041 !=null && !isZero(EBS041)) 
                    return EIS016/EBS041; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //单位资产留存收益 
    public Double calculateSFR040(){ 
            Double EBS076 = currentMap.get("SBS049"); 
            Double lastEBS076 = lastMap.get("SBS049"); 
            Double EBS041 = currentMap.get("SBS026"); 
             
            if(EBS076!=null && lastEBS076 !=null && EBS041!=null && !isZero(EBS041)) 
                    return (EBS076-lastEBS076)/EBS041; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //净资产利润率 
    public Double calculateSFR041(){ 
            Double EIS019 = currentMap.get("SIS014"); 
            Double EBS069 = currentMap.get("SBS050"); 
             
            if(EIS019!=null &&  EBS069!=null && !isZero(EBS069)) 
                    return EIS019/EBS069; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //经营利润与营运资金比率 
    public Double calculateSFR042(){ 
            Double EIS012 = currentMap.get("SIS004"); //二、主营业务利润
            Double EBS003 = currentMap.get("SBS011"); //流动资产合计
            Double EBS043 = currentMap.get("SBS039"); //流动负债合计
             
            if(EIS012!=null &&  EBS003!=null && EBS043!=null && !isZero(EBS003-EBS043)) 
                    return EIS012 / (EBS003-EBS043); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    /* 
     * 流动性 
     */ 
    //流动负债偿付比率a 
    public Double calculateSFR043(){ 
            Double EBS005 = currentMap.get("SBS001"); 
            Double EBS006 = currentMap.get("SBS002"); 
            Double EBS013 = currentMap.get("SBS003"); 
            Double EBS043 = currentMap.get("SBS039"); 
             
            if(EBS005!=null && EBS006!=null &&  EBS013!=null &&  EBS043!=null  &&  
                            !isZero(EBS043)) 
                    return (EBS005 + EBS006 + EBS013) / (EBS043); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //流动负债偿付比率b 
    public Double calculateSFR044(){ 
            Double EBS005 = currentMap.get("SBS001"); 
            Double EBS006 = currentMap.get("SBS002"); 
            Double EBS043 = currentMap.get("SBS039"); 
             
            if(EBS005!=null && EBS006!=null && EBS043!=null && !isZero(EBS043)) 
                    return ( EBS005 + EBS006 ) / EBS043; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //流动负债偿付比率c 
    public Double calculateSFR045(){ 
            Double EBS005 = currentMap.get("SBS001"); 
            Double EBS013 = currentMap.get("SBS003"); 
            Double EBS043 = currentMap.get("SBS039"); 
             
            if(EBS005!=null &&  EBS013!=null &&  EBS043!=null  &&  
                            !isZero(EBS043)) 
                    return (EBS005 + EBS013) / (EBS043); 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //流动负债偿付比率d 
    public Double calculateSFR046(){ 
            Double EBS005 = currentMap.get("SBS001"); 
            Double EBS043 = currentMap.get("SBS039"); 
             
            if(EBS005!=null &&  EBS043!=null &&   !isZero(EBS043)) 
                    return EBS005 / EBS043; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //应收账款流动负债率 
    public Double calculateSFR047(){ 
            Double EBS007 = currentMap.get("SBS005"); 
            Double EBS043 = currentMap.get("SBS039"); 
             
            if(EBS007!=null && EBS043!=null && !isZero(EBS043)) 
                    return EBS007 / EBS043; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
    //速动资产负债率 
    public Double calculateSFR048(){ 
            Double EBS003 = currentMap.get("SBS011"); 
            Double EBS008 = currentMap.get("SBS007"); 
            Double EBS043 = currentMap.get("SBS039"); 
             
            if(EBS003!=null &&  EBS008!=null && EBS043!=null && !isZero(EBS043)) 
                    return (EBS003 - EBS008) / EBS043; 
            else{ 
                    log.error("数据项不存在或分母为空"); 
                    return null; 
            } 
    } 
     
    /* 
     * 规模指标 
     */ 
     
    //主营业务收入净额规模 
    public Double calculateSFR049(){ 
            Double EIS001 = currentMap.get("SIS001"); 
            if(EIS001!=null) 
                    return EIS001; 
            else 
                    return null; 
    } 
     
    //资产总计规模 
    public Double calculateSFR050(){ 
            Double EBS041 = currentMap.get("SBS026"); 
            if(EBS041!=null) 
                    return EBS041; 
            else 
                    return null; 
    } 

	
	//所有者权益合计规模
	public Double calculateSFR051(){
		Double EBS069 = currentMap.get("SBS050");
		if(EBS069!=null)
			return EBS069;
		else
			return null;
	}
	
	//平均主营业务收入净额规模
	public Double calculateSFR052(){
//		Double EIS001 = currentMap.get("EIS001");
//		Double lastEIS001 = lastMap.get("EIS001");
//		if(EIS001!=null && lastEIS001!=null)
//			return (EIS001+lastEIS001)/2;
//		else
//		
		return null;
	}
	
	//平均资产总计规模
	public Double calculateSFR053(){
		Double EBS041 = currentMap.get("SBS026");
		Double lastEBS041 = lastMap.get("SBS026");
		if(EBS041!=null && lastEBS041!=null)
			return (EBS041+lastEBS041)/2;
		else
			return null;
	}
	
	//平均所有者权益合计规模
	public Double calculateSFR054(){
		Double currentEBS069 = currentMap.get("SBS050"); //当年所有者权益
		Double lastEBS069 = lastMap.get("SBS050"); //前一年所有者权益
		
		if(currentEBS069!=null && lastEBS069!=null)
			return (currentEBS069 + lastEBS069)/2;
		else 
			return null;
	}
	
	
	/*
	 * 财务结构
	 */
	
	//长期资产适合率 
	public Double calculateSFR055(){
		Double currentEBS069 = currentMap.get("SBS050"); //所有者权益
		Double currentEBS061 = currentMap.get("SBS043"); //长期负债
		
		Double currentEBS020 = currentMap.get("SBS017"); //固定资产净值
		Double currentEBS021 = currentMap.get("SBS014"); //长期投资合计
		
		if(currentEBS069!=null &&  currentEBS061!=null &&  
				currentEBS020!=null && currentEBS021!=null &&
				!isZero(currentEBS020 + currentEBS021))
			return (currentEBS069 + currentEBS061)/
			(currentEBS020 + currentEBS021);
		else{
			log.error("分母为0");
			return null;
		}		
	}
	
	//付息债务结构比
	public Double calculateSFR056(){
		
		Double currentEBS045 = currentMap.get("SBS027"); //短期借款
		Double currentEBS049 = currentMap.get("SBS028"); //应付票据
		Double currentEBS058 = currentMap.get("SBS037"); //一年内到期的非流动负债
		Double currentEBS061 = currentMap.get("SBS040"); //长期借款
		Double currentEBS068 = currentMap.get("SBS044"); //负债合计
		
		if(currentEBS045 != null && currentEBS049 != null 
				&& currentEBS058 != null && currentEBS061 != null
				 && currentEBS068 != null && !isZero(currentEBS068)){
				Double tempItem = currentEBS045 + currentEBS049 + currentEBS058 + currentEBS061; //总债务
				if( !isZero(tempItem))
					return tempItem/currentEBS068;
				else
					return null;
			}
		
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	//流动负债结构比
	public Double calculateSFR057(){
		
		Double currentEBS043 = currentMap.get("SBS038"); //流动负债合计
		Double currentEBS068 = currentMap.get("SBS044"); //负债合计
		
		if(currentEBS043 != null && currentEBS068 != null && !isZero(currentEBS068))
			return currentEBS043/currentEBS068;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
		
	}
	
	//应付账款负债比
	public Double calculateSFR058(){
		
		Double currentEBS047 = currentMap.get("SBS029"); //应付账款
		
		Double currentEBS043 = currentMap.get("SBS038"); //流动负债合计
		Double currentEBS061 = currentMap.get("SBS043"); //长期负债合计
		
		if(	currentEBS047 != null && currentEBS043 != null 
				&& currentEBS061 != null && !isZero(currentEBS043 + currentEBS061))
			return currentEBS047/(currentEBS043 + currentEBS061);
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	//有形资本净值与长期负债比
	public Double calculateSFR059(){
		Double SBS050 = currentMap.get("SBS050"); //所有者权益期末
		Double lastSBS050 = lastMap.get("SBS050"); //所有者权益期初
		Double SBS043 = currentMap.get("SBS043"); //长期负债合计
		
		if(SBS050 != null && lastSBS050 != null && SBS043 != null && !isZero(SBS043))
			return (SBS050 - lastSBS050) / SBS043;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}		
		
	}
	
	//应收账款与总资产比率
	public Double calculateSFR060(){
		if(currentMap.get("SBS005")!=null && currentMap.get("SBS026")!=null 
				&& !isZero(currentMap.get("SBS026")))
			return currentMap.get("SBS005")/currentMap.get("SBS026");
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	//存货与总资产比率
	public Double calculateSFR061(){
		if(currentMap.get("SBS007")!=null && currentMap.get("SBS026")!=null 
				&& !isZero(currentMap.get("SBS026")))
			return currentMap.get("SBS007")/currentMap.get("SBS026");
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	
	public Double calculateSFR062(){
		
		if(currentMap.get("SBS026")!=null && currentMap.get("SBS011")!=null 
				&& currentMap.get("SBS050")!=null &&!isZero(currentMap.get("SBS050")))
			return (currentMap.get("SBS026")- currentMap.get("SBS011"))/currentMap.get("SBS050");
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
		
	}
	
	public Double calculateSFR063(){
		Double currentEIS026 = currentMap.get("SIS008"); //财务费用
		
		Double currentEBS061 = currentMap.get("SBS040"); //长期借款
		Double currentEBS045 = currentMap.get("SBS027"); //短期借款
		
		if(currentEIS026!=null && currentEBS061!=null && currentEBS045!=null && !isZero(currentEBS061 + currentEBS045))
			return currentEIS026/(currentEBS061 + currentEBS045);
		else{
			log.error("分母为0");
			return null;
		}
		
	} 
	
	public Double calculateSFR064(){
		
		Double currentEBS069 = currentMap.get("SBS050"); //所有者权益
		Double currentEBS041 = currentMap.get("SBS026"); //资产总计
		Double currentEBS003 = currentMap.get("SBS011"); //流动资产合计
		Double currentEBS007 = currentMap.get("SBS005"); //应收账款
		Double currentEBS017 = currentMap.get("SBS006"); //其他应收款
		Double currentEBS008 = currentMap.get("SBS007"); //存货
		
		
		
		if(currentEBS069 != null && currentEBS041 != null 
			&& currentEBS003 != null && currentEBS007 != null 
			&& currentEBS017 != null && currentEBS008 != null){
				Double tempItem = (currentEBS003 - currentEBS007 - currentEBS017 - currentEBS008);
				if(!isZero(currentEBS041 - tempItem))
					return currentEBS069/(currentEBS041 - tempItem);
				else
					return null;
			 }
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	public Double calculateSFR065(){
		Double currentEBS041 = currentMap.get("SBS026"); //资产总计
		Double currentEBS003 = currentMap.get("SBS011"); //流动资产合计
		Double currentEBS061 = currentMap.get("SBS043"); //长期负债
		Double currentEBS069 = currentMap.get("SBS050"); //所有者权益
		
		if(currentEBS041 != null && currentEBS003 != null && currentEBS061 != null 
				&& currentEBS069 != null && !isZero(currentEBS061 + currentEBS069))
			return (currentEBS041 - currentEBS003)/(currentEBS061  + currentEBS069);
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}		
		
	}
	
	public Double calculateSFR066(){
		if(currentMap.get("SIS006")!=null && currentMap.get("SBS007")!=null && !isZero(currentMap.get("SBS007")))
			return currentMap.get("SIS006")/currentMap.get("SBS007");
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	public Double calculateSFR067(){
		
		if(currentMap.get("SBS007")!=null && currentMap.get("SBS011")!=null && !isZero(currentMap.get("SBS011")))
			return currentMap.get("SBS007")/currentMap.get("SBS011");
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}

	
	//TODO  年末贷款余额 公式无
	//净资产与年末贷款余额比率 
	public Double calculateSFR068(){
		Double currentEBS069 = currentMap.get("EBS069"); //所有者权益
		return null;
	}

	/*
	 * 成长性指标
	 */
	
	public Double calculateSFR069(){
		Double EIS001 = currentMap.get("SIS001");
		Double lastEIS001 = lastMap.get("SIS001");
		
		if(EIS001!=null && lastEIS001!=null && !isZero(lastEIS001))
			return (EIS001 - lastEIS001) / EIS001;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	//总资产增长比率 
	public Double calculateSFR070(){
		Double EBS041 = currentMap.get("SBS026");
		Double lastEBS041 = lastMap.get("SBS026");
		
		if(EBS041!=null && lastEBS041!=null && !isZero(lastEBS041))
			return (EBS041 - lastEBS041) / lastEBS041;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	public Double calculateSFR071(){
		Double EBS069 = currentMap.get("SBS050");
		Double lastEBS069 = lastMap.get("SBS050");
		
		if(EBS069!=null && lastEBS069!=null && !isZero(lastEBS069))
			return (EBS069 - lastEBS069) / lastEBS069;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	//净利润增长率
	public Double calculateSFR072(){
		Double EIS019 = currentMap.get("SIS016");
		Double lastEIS019 = lastMap.get("SIS016");
		
		if(EIS019!=null && lastEIS019!=null && !isZero(lastEIS019))
			return (EIS019-lastEIS019)/lastEIS019;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	public Double calculateSFR073(){
		Double SBS044 = currentMap.get("SBS044");
		Double lastSBS044 = lastMap.get("SBS044");
		
		if(SBS044 != null && lastSBS044 != null && !isZero(lastSBS044))
			return (SBS044 - lastSBS044)/lastSBS044;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	public Double calculateSFR074(){
		Double SBS039 = currentMap.get("SBS039");
		
		Double lastSBS039 = lastMap.get("SBS039");
		
		if(SBS039 != null && lastSBS039 !=null && !isZero(lastSBS039)){
			return (SBS039 - lastSBS039)/lastSBS039;
		}
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	public Double calculateSFR075(){
		Double SBS043 = currentMap.get("SBS043");
		
		Double lastSBS043 = lastMap.get("SBS043");
		
		if(SBS043 != null && lastSBS043 != null && !isZero(lastSBS043)){
			return (SBS043 - lastSBS043)/lastSBS043;
		}
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
		
	}
	
	public Double calculateSFR076(){
		Double EIS012 = currentMap.get("SIS009");
		Double lastEIS012 = lastMap.get("SIS009");
		
		if(EIS012!=null && lastEIS012!=null && !isZero(lastEIS012))
			return (EIS012 - lastEIS012) / lastEIS012;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
	
	
	// 主营业务毛率增长率
	//小企业无此项数据，只是为了方便趋势分析显示
	public Double calculateSFR077() {
		return null;
	}
	
	//销售毛利率：（主营业务收入-主营业务成本）/主营业务收入
	public Double calculateSFR083(){
		Double EIS001 = currentMap.get("SIS001");//营业收入
		Double EIS002 = currentMap.get("SIS002");//减：营业成本
		
		
		if(EIS001!=null && EIS002!=null && !isZero(EIS001))
			return (EIS001-EIS002)/EIS001;
		else{
			log.error("数据项不存在或分母为空");
			return null;
		}
	}
}
